// 基本逻辑
type L = 1
type R = 2
type X = 3
type Y = 4
type T = L extends R ? X : Y // L&R, X, Y, X|Y, never

interface Animal {type:string}
interface Zoo<T extends Animal> {}
type MakeZoo<A> = A extends Animal ? Zoo<A> : never // 这里进行了两次 extends Animal 运算
// case 1
type Pig = Animal & {type: 'pig', leg: 4}
type Pig2 = Omit<Pig, never> // {type: 'pig', leg: 4} 会向子类型收敛，收敛结果是子类型本身
type b1 = Pig extends Animal ? true : false
type b2 = (Pig & Animal) extends Animal ? true : false 

// case 2
type Tx<L, R> = L extends R ? ['X', L, R]: ['Y', L, R]
// boolean 是一个联合类型
// boolean = true | false
// 所以 Tx<boolean, true> 等价于 Tx<false, true> | Tx<true, true>
//                             ['Y', false, true] | ['X', true, true]
// 
type b3 = Tx<boolean, true> // ["Y", false, true] | ["X", true, true]
// any 是一个特殊的类型，它表示任意类型
// 它既能赋值给 extends 后面的类型，也不能赋值给 extends 后面的类型
// 所以 Tx<any, never> 等价于 Tx<any, never> 可赋值 | Tx<any, never> 不可赋值
//                               会发生 X = L = L&R
//                             ["X", never, never] | ["Y", any, never]
type b4 = Tx<any, never> // ["X", never, never] | ["Y", any, never]
type b5 = any & never // never

// keyof T
//     - 求值结果T: anything
type T1 = keyof 's' extends string ? true : false // BAD CASE (extends 的优先级比较低)
type T2 = keyof ('s' extends string ? true : false)  // 先进行 extends 运算

// T[x]
//  - 求值结果T: anything
//  - 求值结果x: never | string | symbol | number | subset union, And x in keyof T
type A = {a: string, b: number, c: 1}
type T3 = A['s' extends string ? 'a': false] // NOTE: 注意false分支在这里是无意义的
type T4 = ('s' extends string ? 'a' : never)['toString'] // NOTE: 注意never分支在这里是无意义的

// A | B
//  - 求值结果: anything
type T5 = {} | ('s' extends string ? {a: string}: {})

// A extends B ...
//  - 求值结果: anything
type T7 = 's' extends string
            ? `${number}` extends string
                ? true
                : false
            : never

type T71 = ('s' extends string ? {a: string}: {}) extends
            ('' extends `${number}` ? {a: string}: {}) ? true: false
type T711 = {a: string} extends {} ? true : false

// ...T
//  - 求值结果: never | array | tuple | union
type T8 = [...('s' extends string ? []: never)]


// `${...}`
//  - 求值结果: never | string | number | bigint | boolean | null | undefined | subset union
//  - any
type T9 = `...${'s' extends string ? any: never}`

//  x in U as K
    //  - 求值结果: never | string | number | symbol | subset union
type T10 = {
    [x in 's' extends string ? {a: string}: {} as 
        's' extends string ? keyof {a:string} : keyof {}
    ]: any
}

// 结构类型的成员类型
type T11 = {
    a: 's' extends string ? []: never
}

